var express = require('express');
var router = express.Router();
const mongoose = require('mongoose');
const http = require('http');
const fs = require('fs');
const https = require('https');
let { userModel, roleModel, menuModel, tokenModel,
  friendModel, groupModel, messagerModel, MessageStatusModel, groupRequestModel } = require("../model/model")

let path = require('path')



let jwt = require('jsonwebtoken');
const multiparty = require('multiparty');
const ACCESS_TOKEN_EXPIRATION = '24h'; //访问令牌有效期
const REFRESH_TOKEN_EXPIRATION = '24h'; //刷新令牌有效期
const SECRET_KEY = 'WANGJIALONG';
const refreshTokenMap = new Map();
const socketIo = require('socket.io');


const NodeCache = require('node-cache');
const userCache = new NodeCache({ stdTTL: 3600 }); // 一小时过期  存储用户ID和Socket ID映射

const keyPath = path.resolve(__dirname, './key.pem');
const certPath = path.resolve(__dirname, './cert.pem');

const options = {
  key: fs.readFileSync(keyPath),
  cert: fs.readFileSync(certPath),
  passphrase: 'lgy549399', // 如果私钥是加密的，提供密码
};



const server = https.createServer(options);

// 初始化 socket.io
const io = socketIo(server, {
  pingInterval: 10000,  // 默认 25000ms，调整为适应实际需求
  pingTimeout: 5000,    // 默认 5000ms，控制超时
  transports: ['websocket'], // 强制使用 WebSocket 协议
  compression: true,         // 启用压缩，减少数据传输量
  cors: {
    origin: ['http://localhost:5173', 'https://localhost:5173'], // 前端地址
    methods: ['GET', 'POST'],
    allowedHeaders: ['Content-Type'],
  }
});

// 记录用户请求的时间戳
const userRequestCache = new Map();
const RATE_LIMIT_WINDOW = 1000;  // 1秒的时间窗口
const MAX_REQUESTS_PER_WINDOW = 1;  // 每秒最多允许5个请求
// 独立的速率限制函数
function rateLimitSocket(userId) {
  console.log("执行了！--------------------");
  const currentTime = Date.now();

  if (!userRequestCache.has(userId)) {
    userRequestCache.set(userId, []);
  }

  const requestTimestamps = userRequestCache.get(userId);

  // 移除过期的时间戳（超出1秒的请求）
  const validTimestamps = requestTimestamps.filter(timestamp => currentTime - timestamp < RATE_LIMIT_WINDOW);
  userRequestCache.set(userId, validTimestamps);

  // 如果请求数超过最大限制，返回 false
  if (validTimestamps.length >= MAX_REQUESTS_PER_WINDOW) {
    return false; // 请求过多
  }

  // 记录当前请求
  validTimestamps.push(currentTime);
  userRequestCache.set(userId, validTimestamps);

  return true; // 请求合法
}


io.use((socket, next) => {
  console.log("开始验证身份");

  // 从握手请求中获取 token 参数
  const token = socket.handshake.query.token;

  if (!token) {
    return next(new Error('No token provided'));
  }

  try {
    // 使用 JWT 解析令牌并验证
    const user = jwt.verify(token, SECRET_KEY);
    socket.user = user; // 将用户信息绑定到 socket 上，后续可以通过 socket.user 访问
    next();  // 验证通过，允许连接
  } catch (err) {
    console.error('JWT 验证失败', err);
    next(new Error('Authentication error'));  // 验证失败，拒绝连接
  }
});


// 当用户连接时
io.on("connect", (socket) => {
  console.log("用户已连接", socket.id)

  socket.on('ping', () => {
    // 服务器主动不回应 pong 以测试超时
    // socket.emit('pong');  // 默认是自动回应的
  });
  // 监听用户登录
  socket.on("login", async (userID) => {
    // 存储用户的Socket ID
    userCache.set(userID, socket.id)
    console.log(`用户 ${userID} 已登录,SocketID:${socket.id}`);
    // 获取未处理的好友请求(状态为0,待处理)
    const pendingRequests = await friendModel.find({
      friendID: userID,
      status: 0
    }).populate("userID", "username")
    // 如果有未处理的请求，发送给客户端
    if (pendingRequests.length > 0) {
      socket.emit("pendingFriendRequests", pendingRequests)
    }
  })
  // 监听消息的发送
  socket.on("sendMessage", async (messageData) => {
    const userId = messageData.sender_id || socket.userId; // 获取当前用户ID
    const receivedSize = Buffer.byteLength(JSON.stringify(messageData), 'utf-8');
    console.log('接收后数据大小 (可能已压缩):', receivedSize);
    // 应用速率限制
    const isAllowed = rateLimitSocket(userId);
    if (!isAllowed) {
      socket.emit("error", "Too many requests, please try again later");
      return;
    }
    const newMessage = new messagerModel(messageData);
    await newMessage.save();
    // 判断消息是否有效
    if (!messageData.receive_id && !messageData.group_id) {
      console.log("缺少接收者或群组 ID");
      return;
    }
    // 判断是否是群聊消息
    if (messageData.is_group_message) {
      // 群聊消息，向所有群成员发送消息
      const groupMembers = await groupModel.findOne({ _id: messageData.group_id });
      // 使用 Promise.all 并发发送群消息
      await Promise.all(groupMembers.members.map(async (memberID) => {
        const memberIDStr = memberID.toString();  // 将 ObjectId 转换为字符串
        const socketId = userCache.get(memberIDStr);  // 获取对应的 socketId
        if (socketId) {
          io.to(socketId).emit("receiveMessage", newMessage);
        }
      }));
    } else {
      // 私聊消息，向接收者发送消息
      const friendSocketId = userCache.get(messageData.receive_id);  // 获取接收者的socketId
      const friendSocket = io.sockets.sockets.get(friendSocketId);  // 获取接收者的socket对象
      // 向发送者更新消息列表
      const senderSocketId = userCache.get(messageData.sender_id);  // 获取发送者的socketId
      const senderSocket = io.sockets.sockets.get(senderSocketId);  // 获取发送者的socket对象
      // 向接收者发送消息
      if (friendSocket) {
        // 接收者在线，推送私聊消息
        friendSocket.emit("receiveMessage", newMessage);
      } else {
        console.log("接收者不在线，无法发送消息");
      }
      // 向发送者推送自己的消息
      senderSocket.emit("receiveMessage", newMessage);
      // 发送者的消息列表更新事件
      senderSocket.emit("updateMessageList", {
        sender_id: messageData.sender_id,
        newMessage: newMessage  // 更新发送者的消息列表
      });
    }
  });

  // 用户断开连接
  socket.on("userDisconnect", (userID) => {
    // 从映射中删除用户的 SocketID
    userCache.del(userID);
    console.log(`用户 ${userID} 已断开连接`);
  });
  // 监听断开连接事件
  socket.on("disconnect", () => {
    // 查找并删除用户的SocketID
    for (let userID of userCache.keys()) {
      if (userCache.get(userID) === socket.id) {
        userCache.del(userID);
        console.log(`用户 ${userID} 已断开连接`);
        break;
      }
    }
  });
})

server.listen(3666, () => {
  console.log("服务器已启动，监听端口 3666")
})

// 生成函数令牌
function generateToken(name, expiration) {
  return jwt.sign({ name }, SECRET_KEY, { expiresIn: expiration });
}

// 封装生成短token和长token
function getToken(name) {
  let accessToken = generateToken(name, ACCESS_TOKEN_EXPIRATION); //短Token
  let refreshToken = generateToken(name, REFRESH_TOKEN_EXPIRATION); //长Token
  const refreshTokens = refreshTokenMap.get(name) || [];
  refreshTokens.push(refreshToken);
  refreshTokenMap.set(name, refreshTokens);
  return {
    accessToken,
    refreshToken,
  };
}

//=================================>手机号密码登录
router.post("/login", async (req, res) => {
  let { username, password } = req.body
  let uls = await userModel.findOne({ username })
  if (!uls) {
    return res.status(200).send({ message: "该用户未注册", code: 1 })
  }
  if (uls.password !== password) {
    return res.status(200).send({ message: "密码错误", code: 2 })
  }
  let roleid = await roleModel.find({ _id: uls.roleid })
  let { accessToken, refreshToken } = getToken(uls.username)
  res.send({
    code: 200,
    message: "登录成功",
    roleid: roleid[0].name === '超级管理员' ? 'admin' : 'user',
    username: uls,
    accessToken,
    refreshToken
  })
})

// 刷新短token
router.get('/refresh', async (req, res) => {
  const refreshToken = req.headers.refreshtoken;
  if (!refreshToken) {
    res.status(403).send('Forbidden');
  }
  try {
    const { name } = jwt.verify(refreshToken, SECRET_KEY);
    const accessToken = generateToken(name, ACCESS_TOKEN_EXPIRATION);
    res.status(200).send({ accessToken });
  } catch (error) {
    console.log('长token已过期');
    res.status(403).send('Forbidden');
  }
});


//头像
router.post('/upload', (req, res) => {
  let form = new multiparty.Form();
  form.uploadDir = 'upload';
  form.parse(req, function (err, fields, files) {
    res.send({
      code: 200,
      msg: "上传成功",
      img: "http://localhost:3000/" + files.avatar[0].path
    })
  });
})

//用户注册
router.post('/addUser', async (req, res) => {
  let { username, phone } = req.body
  let uls = await userModel.find({ username, phone })

  if (uls.length > 0) {
    res.send({
      code: 202,
      msg: "该手机号或用户名已注册",
    })
  } else {
    let user = await userModel.create(req.body)
    res.send({
      code: 200,
      msg: "注册成功",
      user
    })
  }
})

//修改密码
router.post('/changePassword', async (req, res) => {
  let body = req.body
  let _id = body._id
  await userModel.updateOne({ _id: _id }, { $set: { password: body.password } })
  res.send({
    code: 200,
    msg: "修改成功"
  })
})

//修改个人信息;
router.post('/changeInfo', async (req, res) => {
  let body = req.body
  let _id = body._id
  await userModel.updateOne({ _id: _id }, { $set: { username: body.username, phone: body.phone, imgUrl: body.imgUrl, remark: body.remark } })
  res.send({
    code: 200,
    msg: "修改成功"
  })
})

// 添加用户
router.post("/addUser", async (req, res) => {
  let data = req.body
  await userModel.create(data)
  res.send({
    code: 200,
    msg: "添加成功"
  })
})

//获取无限极查询内容
router.get("/getmenulist", async (req, res) => {
  let _id = req.query._id
  let [{ menuid }] = await roleModel.find({ _id })
  let menulist = await menuModel.find({ _id: { $in: menuid } }).lean()
  let json = {}
  menulist.forEach(item => {
    json[item._id] = item
  })
  let data = []
  menulist.forEach(item => {
    if (!item["pid"]) {
      data.push(item)
    } else {
      if (json[item.pid] && !json[item.pid]["children"]) {
        json[item.pid]["children"] = []
      }
      json[item.pid] && json[item.pid]["children"].push(item)
    }
  })
  res.send({
    code: 200,
    msg: "获取成功",
    data
  })
})

// 添加路由
router.post("/addmenu", async (req, res) => {
  await menuModel.create(req.body)
  res.send({
    code: 200,
    msg: "添加成功"
  })
})

// 查找可以添加为好友的用户
router.post("/getOneUser", async (req, res) => {
  const { username, userID } = req.body;  // 获取当前用户名和用户ID
  if (!username) {
    return res.send({
      code: 400,
      msg: "请输入查找用户姓名",
    });
  }
  let result = [];
  if (username === "全部") {
    result = await userModel.find();
  } else {
    // 模糊查询所有名字带有username的用户
    result = await userModel.find({ username: { $regex: new RegExp(username, "i") } });
  }
  if (result.length === 0) {
    return res.send({
      code: 202,
      msg: "未找到该用户",
      data: null,
    });
  }
  // 查询所有好友请求状态
  const friendRequests = await friendModel.find({
    $or: [
      { userID, friendID: { $in: result.map(user => user._id) } }, // 查找当前用户发出的请求
      { userID: { $in: result.map(user => user._id) }, friendID: userID } // 查找目标用户发出的请求
    ]
  });
  // 将好友请求状态映射到用户
  const friendRequestMap = friendRequests.reduce((map, request) => {
    const key = request.userID.toString() === userID.toString() ? request.friendID.toString() : request.userID.toString();
    map[key] = request.status;
    return map;
  }, {});
  // 过滤可以添加为好友的用户（status 0 或 2）
  const updatedResult = result.filter(user => {
    if (user._id.toString() === userID.toString()) return false; // 跳过当前用户

    const status = friendRequestMap[user._id.toString()] || 0;  // 如果没有请求记录，默认为待处理（0）
    return status === 0 || status === 2;  // 只返回待处理（0）或已拒绝（2）的请求
  });
  // 返回符合条件的用户数据，包含好友请求状态
  return res.send({
    code: 200,
    msg: "查找成功",
    data: updatedResult.map(user => ({
      ...user.toObject(),
      friendshipStatus: friendRequestMap[user._id.toString()] || 0,  // 如果没有记录，默认为待处理（0）
    })),
  });
});

// 发起好友请求
router.post("/sendFriend", async (req, res) => {
  const { userID, friendID } = req.body;
  // 查询数据库中是否已有相同的好友请求
  const existingRequest = await friendModel.findOne({
    $or: [
      { userID, friendID },
      { userID: friendID, friendID: userID }
    ]
  });
  if (existingRequest) {
    if (existingRequest.status === 1) {
      // 如果状态为1，表示已经是好友，返回提示
      return res.send({
        code: 400,
        msg: "已经是好友"
      });
    }
    // 如果状态为 0 或 2，表示请求已经存在或者正在处理中，可以继续发起请求
  }
  // 创建新的好友请求，status 为 0 表示待处理
  const newRequest = new friendModel({ userID, friendID, status: 0 });
  await newRequest.save();
  // 查找接收方的 socketId
  const friendSocketId = userCache.get(friendID);  // 从缓存中获取 friendID 对应的 socketId
  // 如果接收方的 socketId 存在，则发送新好友请求的通知
  if (friendSocketId) {
    const friendSocket = io.sockets.sockets.get(friendSocketId); // 获取接收方的 socket 对象
    if (friendSocket) {
      // 向接收方发送“有新好友请求”的通知
      friendSocket.emit("newFriendRequest", {
        from: userID,
        to: friendID
      });
    }
  }
  // 返回 200 状态和消息
  res.send({
    code: 200,
    msg: "请求消息已发送"
  });
});

// 获取离线未处理的好友请求
router.post("/getPendingRequests", async (req, res) => {
  const { userID } = req.body
  const requesets = await friendModel.find({
    friendID: userID,
    status: 0, //只查找待处理的请求
  }).populate("userID", "username")
  res.send({
    code: 200,
    msg: "获取未处理请求成功",
    data: requesets
  })
})

// 同意好友请求
router.post("/acceptFriend", async (req, res) => {
  const { requestId, userID, friendID } = req.body;
  const request = await friendModel.findById(requestId);
  if (!request || request.status !== 0) {
    res.send({
      code: 400,
      msg: "请求不存在或已处理"
    })
  }
  request.status = 1;
  await request.save();
  // 通知对方该好友请求已被接受
  const friendSocketId = userCache.get(friendID);  // 获取接收方的socketId
  if (friendSocketId) {
    const friendSocket = io.sockets.sockets.get(friendSocketId) //获取接收方的socket对象
    if (friendSocket) {
      // 向接收方发送“好友请求已被接受”的通知
      friendSocket.emit("friendRequestProcessed", { msg: "好友请求已被接受" })
    }
  }
  res.send({
    code: 200,
    msg: "好友请求已接收"
  })
})

// 拒绝好友请求
router.post("/rejectFriend", async (req, res) => {
  const { requestId, userID, friendID } = req.body;
  const request = await friendModel.findById(requestId);
  if (!request || request.status !== 0) {
    res.send({
      code: 400,
      msg: "请求不存在或已处理"
    })
  }
  request.status = 2;
  await request.save();
  // 通知对方该好友请求已被拒绝
  const friendSocketId = userCache.get(friendID);  // 获取接收方的socketId
  if (friendSocketId) {
    const friendSocket = io.sockets.sockets.get(friendSocketId) //获取接收方的socket对象
    if (friendSocket) {
      // 向接收方发送“好友请求已被拒绝”的通知
      friendSocket.emit("friendRequestProcessed", { msg: "好友请求已被拒绝" })
    }
  }
  res.send({
    code: 200,
    msg: "好友请求已被拒绝"
  })
})

// 获取当前用户的好友列表
router.post("/getFriends", async (req, res) => {
  const { userID } = req.body;
  // 获取好友列表，直接包含头像信息
  const friends = await friendModel.find({
    $or: [
      { userID, status: 1 },           // 当前用户发起的已接受请求
      { friendID: userID, status: 1 }   // 其他用户发起的已接受请求
    ]
  })
    .populate("userID", "username imgUrl")  // 只取 username 和 imgUrl
    .populate("friendID", "username imgUrl");
  // 提取并构建好友列表
  const friendList = friends.map(item => {
    // 根据 userID 判断返回 friendID 或 userID
    const friend = item.userID._id.toString() === userID ? item.friendID : item.userID;
    return {
      _id: friend._id,
      username: friend.username,
      imgUrl: friend.imgUrl || 'https://img.ixintu.com/download/jpg/20210107/af6cdb58ec2fbf0a56036cdf7e72d454_512_512.jpg!bg'  // 如果没有头像，返回默认头像
    };
  });
  // 返回好友列表
  res.send({
    code: 200,
    msg: "获取好友列表成功",
    data: friendList
  });
});

// 获取单个用户详细信息
router.post("/gerUserInfo", async (req, res) => {
  const { userID } = req.body;
  const user = await userModel.findById(userID);
  if (user) {
    res.send({
      code: 200,
      msg: "用户信息获取成功",
      data: user
    })
  } else {
    res.send({
      code: 202,
      msg: "未找到该用户",
      data: null
    })
  }
})

// 更新用户信息
router.post("/updateUserInfo", async (req, res) => {
  const { userID, updateData } = req.body;
  const updateUser = await userModel.findByIdAndUpdate(userID, updateData, { new: true });
  if (updateUser) {
    res.send({
      code: 200,
      msg: "用户信息更新成功",
      data: updateUser
    })
  } else {
    res.send({
      code: 400,
      msg: "更新失败",
    })
  }
})

// 创建群聊
router.post("/createGroup", async (req, res) => {
  const { userID, name, members } = req.body; //获取用户ID、群名称、群成员
  // 创建新的群聊
  const newGroup = new groupModel({
    userID,   //群主id
    name,     //群名称
    members,  //群成员列表
  })
  await newGroup.save();
  res.send({
    code: 200,
    msg: "创建群聊成功",
    data: newGroup
  })
})

// 邀请好友进入群聊
router.post("/sendFriendToGroup", async (req, res) => {
  const { groupID, userID, friendID } = req.body;  // 获取群聊ID、邀请人ID、被邀人ID
  // 检查是否已经发送过邀请
  const existingInvite = await groupRequestModel.findOne({
    userID,
    friendID,
    groupID,
    status: 0  // 只考虑待处理的邀请
  });
  if (existingInvite) {
    return res.status(400).send({ code: 400, msg: "邀请已存在，等待对方处理" });
  }
  // 创建新的群聊邀请
  const newInvite = new groupRequestModel({
    userID,
    friendID,
    groupID,
    status: 0,  // 默认状态为待处理
  });
  await newInvite.save();
  // 向被邀请的好友发送群聊邀请通知
  const friendSocketId = userCache.get(friendID);  // 获取被邀请者的 socketId
  if (friendSocketId) {
    const friendSocket = io.sockets.sockets.get(friendSocketId);
    if (friendSocket) {
      friendSocket.emit("newGroupInvite", {
        from: userID,
        to: friendID,
        groupID
      });
    }
  }
  res.send({
    code: 200,
    msg: "邀请已发送，等待对方处理",
  });
});

// 获取待处理的群聊邀请
router.post("/getPendingGroupInvites", async (req, res) => {
  const { userID } = req.body;
  // 查找用户收到的待处理群聊邀请
  const invites = await groupRequestModel.find({
    friendID: userID,
    status: 0,  // 只查找待处理的邀请
  }).populate("userID", "username")  // Populate 群主的用户名
    .populate("groupID", "name");   // Populate 群聊的名称
  res.send({
    code: 200,
    msg: "获取待处理的群聊邀请成功",
    data: invites
  });
});

// 用户接受或拒绝群聊邀请
router.post("/respondToGroupInvite", async (req, res) => {
  const { inviteID, userID, status } = req.body;  // 获取请求中的 inviteID, userID 和 status（1 - 接受，2 - 拒绝）

  // 查找邀请记录
  const invite = await groupRequestModel.findById(inviteID);
  if (!invite) {
    return res.status(404).send({ code: 404, msg: "邀请记录不存在" });
  }

  // 更新邀请的状态
  invite.status = status;  // 更新为接受（1）或拒绝（2）
  await invite.save();

  if (status === 1) {
    // 用户接受邀请，加入群聊
    const group = await groupModel.findById(invite.groupID);
    if (!group) {
      return res.status(404).send({ code: 404, msg: "群聊不存在" });
    }

    // 检查用户是否已经在群聊中
    if (group.members.includes(userID)) {
      return res.status(400).send({ code: 400, msg: "用户已经在群里" });
    }

    // 添加新成员到群聊
    group.members.push(userID);
    await group.save();

    // 向群聊广播新成员加入的通知
    const groupMembers = await groupModel.findOne({ _id: invite.groupID });
    groupMembers.members.forEach(memberID => {
      const memberIDStr = memberID.toString();  // 将 ObjectId 转换为字符串
      const socketId = userCache.get(memberIDStr);  // 获取对应的 socketId
      if (socketId) {
        io.to(socketId).emit("newGroupMember", {
          newMemberID: userID,
          groupID: invite.groupID
        });
      }
    });
    // 向被邀请者发送成功加入群聊的通知
    const friendSocketId = userCache.get(userID);  // 获取新加入群聊的用户的 socketId
    if (friendSocketId) {
      const friendSocket = io.sockets.sockets.get(friendSocketId);
      if (friendSocket) {
        friendSocket.emit("groupInviteSuccess", {
          groupID: invite.groupID,
          groupName: group.name
        });
        console.log(`群聊邀请成功，用户 ${userID} 已加入群聊 ${group.name}`);
      }
    }

    return res.send({
      code: 200,
      msg: "加入群聊成功"
    });
  } else if (status === 2) {
    // 用户拒绝邀请
    return res.send({
      code: 200,
      msg: "邀请已拒绝"
    });
  } else {
    return res.status(400).send({ code: 400, msg: "无效的状态值" });
  }
});


// 获取群列表
router.post("/getGroups", async (req, res) => {
  const { userID } = req.body;
  // 获取用户创建的群聊
  const createGroups = await groupModel.find({ userID })
  // 获取用户加入的群聊
  const joinGroups = await groupModel.find({ members: userID })
  // 合并两个数组
  const allGroups = [...createGroups, ...joinGroups]
  // 使用reduce去重，确保群里不重复
  const uniqueGroups = allGroups.reduce((acc, group) => {
    if (!acc.some(g => g._id.toString() === group._id.toString())) {
      acc.push(group)
    }
    return acc;
  }, [])
  res.send({
    code: 200,
    msg: "获取群列表成功",
    data: uniqueGroups
  })
})

// 获取所有用户，排除群聊中的成员和已经被邀请的待处理用户
router.post("/getGroupMembers", async (req, res) => {
  const { groupID } = req.body;
  // 获取群组信息并填充成员
  const group = await groupModel.findById(groupID).populate("members", "_id");
  // 获取群组成员的用户ID数组
  const groupMemberIDs = group.members.map(member => member._id);
  // 查找待处理的邀请（status: 0，即邀请已发送但未接受或拒绝）
  const pendingInvites = await groupRequestModel.find({
    groupID,
    status: 0
  }).select("friendID");  // 只需要获取被邀请人的ID
  // 提取所有待处理邀请的用户ID
  const pendingInviteIDs = pendingInvites.map(invite => invite.friendID);
  // 获取所有用户，但排除群聊中的成员和已被邀请的待处理用户
  const users = await userModel.find({
    _id: {
      $nin: [...groupMemberIDs, ...pendingInviteIDs]  // 排除群聊成员和待处理邀请的用户
    }
  }, "username _id imgUrl"); // 只返回用户名、用户ID和头像
  res.send({
    code: 200,
    msg: "获取非群聊成员和未处理邀请的用户成功",
    data: users
  });
});

//获取角色
router.get('/rolelist', async (req, res) => {
  let data = await roleModel.find()
  res.send({
    code: 200,
    msg: "获取成功",
    data
  })
})

//发送消息接口
router.post('/sendMessage', async (req, res) => {
  const { sender_id, receive_id, group_id, content, context_type, media_url, is_group_message } = req.body;
  // 判断消息是群聊消息还是私聊消息
  let newMessage = new messagerModel({
    sender_id,
    receive_id,
    group_id,
    content,
    context_type,
    media_url,
    is_group_message,
  });
  try {
    // 保存消息
    await newMessage.save();
    // 如果是群聊消息，需要创建消息状态记录
    if (is_group_message) {
      const group = await groupModel.findById(group_id);
      const memberIds = group.members;
      // 群聊消息，直接通知所有群成员
      memberIds.forEach(async (userId) => {
        if (userId.toString() !== sender_id.toString()) {  // 排除发送者
          // 可在此处实现通知逻辑（例如发送到 socket.io）
          // io.to(userId).emit('receiveMessage', newMessage);
        }
      });
    } else {
      // 私聊消息，无需创建消息状态记录
      // 可在此处实现通知逻辑（例如发送到 socket.io）
      // io.to(receive_id).emit('receiveMessage', newMessage);
    }
    res.send({
      code: 200,
      msg: "消息发送成功",
      data: newMessage
    });
  } catch (err) {
    console.error(err);
    res.status(500).send({ code: 500, msg: "消息发送失败" });
  }
});

// 获取消息（群聊或私聊）
router.post('/getmessages', async (req, res) => {
  const { user_id, group_id, receiver_id } = req.body;
  let query = {};
  // 如果有 group_id，说明是群聊消息
  if (group_id) {
    query.group_id = group_id;
  } else {
    // 如果没有 group_id 且有 receiver_id 和 user_id，说明是私聊消息
    query = {
      $or: [
        { sender_id: user_id, receive_id: receiver_id },
        { sender_id: receiver_id, receive_id: user_id },
      ]
    };
  }
  try {
    // 获取符合条件的消息，并按时间排序
    const messages = await messagerModel.find(query).sort({ createdAt: 1 });
    // 如果没有消息
    if (messages.length === 0) {
      return res.send({
        code: 200,
        msg: "没有找到消息",
        data: [],
      });
    }
    // 获取所有发送消息用户的 user_id
    const senderIds = [...new Set(messages.map(msg => msg.sender_id))];
    // 查询所有发送者的头像和名称，这里使用了 ObjectId 类型的匹配
    const users = await userModel.find({
      _id: { $in: senderIds.map(id => new mongoose.Types.ObjectId(id)) }
    }, '_id imgUrl username'); // 增加了 'username' 字段
    // 构建发送者头像和名称的映射
    const senderInfoMap = users.reduce((acc, user) => {
      acc[user._id.toString()] = {
        avatar: user.imgUrl,
        username: user.username,  // 获取用户名
      };
      return acc;
    }, {});
    // 将头像和用户名信息添加到每条消息
    const messagesWithAvatarsAndNames = messages.map(msg => ({
      ...msg.toObject(), // 把原消息转换为普通对象
      sender_avatar: senderInfoMap[msg.sender_id.toString()]?.avatar || null, // 使用映射获取头像
      sender_name: senderInfoMap[msg.sender_id.toString()]?.username || null, // 使用映射获取用户名
    }));
    res.send({
      code: 200,
      msg: "获取消息成功",
      data: messagesWithAvatarsAndNames,
    });
  } catch (err) {
    console.error(err);
    res.status(500).send({ code: 500, msg: "获取消息失败" });
  }
});




module.exports = router;